// /**
//  * 给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
//  * 假设我们的环境只能存储得下 32 位的有符号整数。
//  * 请根据这个假设，如果反转后整数溢出那么就返回 0。
//  * @param {number} x
//  * @return {number}
//  */
// var reverse = function(x) {
//     let re ,fh='';
//     if(x<0){
//         fh = "-";
//         x = 0 - x;
//     }
//     re = (x+"").split("").reverse().join("");
//     if(re.length>10 || re.length === 10 && re > (x<0?"2147483648":"2147483647")){
//         return 0;
//     }else{
//         return fh + re;
//     }
// };
// let a = reverse(123)
// console.log(a)
// /**
//  * 将一个给定字符串根据给定的行数，以从上往下、从左到右进行 Z 字形排列。
//  * @param {string} s
//  * @param {number} numRows
//  * @return {string}
//  */
// var convert = function(s, numRows) {
//     if(numRows == 1)
//         return s;

//     const len = Math.min(s.length, numRows);
//     const rows = [];
//     for(let i = 0; i< len; i++){
//         rows[i] = "";
//     }
//     let loc = 0;
//     let down = false;

//     for(const c of s) {
//         rows[loc] += c;
//         if(loc == 0 || loc == numRows - 1){
//             down = !down; //到底了就应该向右了
//         } 
//         loc += down ? 1 : -1;
//     }

//     let ans = "";
//     for(const row of rows) {
//         ans += row;
//     }
//     return ans;
// };

// // let ans = convert('LEETCODEISHIRING',3)
// // console.log(ans)

// /**
//  * 给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
//  * 输入: "babad"
//     输出: "bab"
//     注意: "aba" 也是一个有效答案。

//     输入: "cbbd"
//     输出: "bb"

//     看了一早上，看不懂
// */

// /**
//  * @param {string} s
//  * @return {string}
//  */
// var longestPalindrome = function(s) {

// };

/**
 * 
//  */
// var lengthOfLongestSubstring = function (s) {
//     //定义一个空数组,存放无重复字符
//     let arr = []
//     for (let i = 0; i < s.length; i++) {
//         //如果这个字符数组里没有就push进去
//         if (s[i] === s[i + 1] && !arr.includes(s[i + 1])) {
//             arr.shift()
//         }
//         if (!arr.includes(s[i])) {
//             arr.push(s[i])
//         }

//     }
//     return arr
// }


// var lengthOfLongestSubstring = function (s) {
//     let left = 0; // 游标左侧位置下标
//     let len = 0; // 最大子串长度
//     let str = ''; // 当前游标子串
//     for (let i = 0; i < s.length; i++) {
//         const span = str.indexOf(s[i]);
//         if (span > -1) {
//             //如果当前有这同样的值，就移动位置，向前一步
//             left = span + 1; // 游标左侧右移span+1位，右侧补上当前字符
//             str = str.substr(span + 1) + s[i]; // substr（开始的index，想要截取的个数）加上新的拼上去的i
//         } else {
//             //如果没有的话，当前的字符串拼接上，对比len的长度，及时更新
//             str += s[i];
//             len = str.length > len ? str.length : len // 更新最大长度
//         }
//     }
//     return len;
// };

// const aa = lengthOfLongestSubstring("pwwkew")

// console.log(aa)


// /**
//  * @param {string[]} strs
//  * @return {string}
//  */
// var longestCommonPrefix = function(strs) {
//     //取出数组的第一位作为目标
//     let result = []
    
//     for(let i =0 ; i<strs.length;i++){
//         let temp = strs[i].substr(i)

//         if(){

//         }
//     }
//     return result
// };

// var longestCommonPrefix = function(strs) {
//     let t = strs[0] || ''; //取出数组的第一位作为目标
//     let i = 1;
//     while(t && i < strs.length) { //循环去删除当前的元素，毕竟是最大的前坠 那么说明每一个都有，所以选取第一个没有关系。
//         //查看是否有包含关系 没有的话 则从末尾开始截取，因为是前缀
//         if(strs[i].indexOf(t) != 0) {
//             t = t.slice(0,-1); //slice(起始位置，结束位置)
//         } else {
//             i++;
//         }
//     }
//     return t;
// };

// const aa = longestCommonPrefix(["flower","flow","flight"])

// console.log(aa)

/**
 * @param {string} s1
 * @param {string} s2
 * @return {boolean}
 */
// // var checkInclusion = function(s1, s2) {
// //     if(s2.indexOf(s1) >-1 || s2.indexOf(s1.split('').reverse().join(''))>-1){
// //         return true
// //     }else{
// //         return false
// //     }

// // };



// const checkInclusion = function(s1, s2) {
//     const l1 = s1.length
//     const l2 = s2.length
//     const v1 = new Vector()
//     const v2 = new Vector() 
//     for (let i = 0; i < l1; i++) {
//       v1.add(s1[i])
//     }
//     for (let j = 0; j < l2; j++) {
//       v2.add(s2[j])
//       console.log(v2)
//       if (j >= l1) {
//         v2.delete(s2[j - l1]) //???
//       }
//       if (v1.equals(v2)) return true
//     }
//     return false
//   };
  
//   class Vector {
//     constructor() {
//       this.map = Array.from(Array(26)).map(() => 0)
//     }
//     add(char) {
//       this.map[char.charCodeAt() - 97]++
//     }
//     delete(char) {
//       this.map[char.charCodeAt() - 97]--
//     }
//     equals(vector) {
//       return this.map.toString() === vector.map.toString()
//     }
//   }
// var checkInclusion = function(s1, s2) {
//     let n1 = s1.length,n2 = s2.length;
//     if(n1 > n2) return false;
//     let count = new Array(26).fill(0);
//     let isAllZero = (count) => {
//         return count.every( val => val === 0);
//     }
//     for(let i = 0;i < n1;i++){
//         count[s1[i].charCodeAt() - 97]++;
//         count[s2[i].charCodeAt() - 97]--;
//     }
//     if(isAllZero(count)) return true;
//     for(let i = n1;i < n2;i++){
//         count[s2[i - n1].charCodeAt() - 97]++;
//         count[s2[i].charCodeAt() - 97]--;
//         if(isAllZero(count)) return true;
//     }
//     return false;
// };

//   const aa = checkInclusion('ab','bbbca')

//   console.log(aa)

// var multiply = function(num1, num2) {
//     const left = '0'.charCodeAt(0);
//     // 首先将字符串用 charCodeAt 转换成对应的数字。
//     // num1Arr 取较短的数字， num2Arr 取较长的数字，用 num1Arr 去分别乘 num2Arr 速度会提升15ms
//     const num1Arr = (num1.length > num2.length ? num2 : num1).split('').map(item => item.charCodeAt(0) - left);
//     const num2Arr = (num1.length > num2.length ? num1 : num2).split('').map(item => item.charCodeAt(0) - left);
//     let res = [];
//     debugger
//     for (let i = num1Arr.length - 1; i > -1; i--) {
//         for (let j = num2Arr.length - 1; j > -1; j--) {
//             debugger
//             // 数字的相乘的结果转换为数组，并且 reverse，方便计算
//             const resArr = (num1Arr[i] * num2Arr[j]).toString().split('');
//             resArr.reverse();
//             const index = num2Arr.length - 1 - j + num1Arr.length - 1 - i;
//             let next = 0, k = 0;
//             while (k < resArr.length || next !== 0) {
//                 // 结果当前位数加上前一位的进位
//                 let sum = (res[index + k] | 0) + next;
//                 // 若 k < resArr，即非最后一位进位
//                 if (k < resArr.length) {
//                     sum += +resArr[k];
//                 }
//                 res[index + k] = sum % 10;
//                 // 若 sum 大于10，进位 = 1
//                 next = sum / 10 >= 1 ? 1: 0;
//                 k++;
//             }
//         }
//     }
//     // 去除结果前的 0
//     while (res.length > 1 && res[res.length - 1] === 0) {
//         res.pop();
//     }
//     return res.reverse().join('');
// };

// console.log(multiply('123','456'))

// function res(people,likesArr,q,selectObj){  
//     for(let i = 0; i < q; i++){  
//         let bef = selectObj[i][0];// 1 2 1    
//         let aft = selectObj[i][1];// 2    
//         let c = selectObj[i][2];    
//         let com = likesArr.slice(bef-1, aft-1);    
//         let num = 0;    
//         if(com.length > 0){  
//             for(let j = 0; j < com.length; j++){
//                 if(com[j] === c){ 
//                num++;
//             }
//           }
//       }
//       console.log(num);
//     }
// } 
// res(5,[1,2,3,3,5],3,[[1,2,1],[2,4,5],[3,5,3]]);

// var users=[{
//    id:1,name:"a"
// },{
//    id:2,name:"a"
// },{
//    id:3,name:"b"
// },{
//    id:4,name:"v"
// }]
// Array.prototype.unique = function () {
//     let arr = []
//     for(let i =0 ;i<users.length;i++){
//       if(!arr.includes(users[i]['name'])){
//           arr.push(users[i]['name'])
//       }
//   }

//     return arr 
// }
// console.log(users.unique());


// let handle=(tager,key)=>{
  
// }


// const man={
//     name:'jscoder',
//     age:22
// }
//  //补全代码
// const proxy = new Proxy(man,{
//  get:function(tager,key){
//       try {
//          if(tager.key){
//          console.log(tager.key)
//       }
//       } catch (error) {
//          console.log(error)
//       }
      
      
//    }
// })
// proxy.name //"jscoder"
// proxy.age //22
// proxy.location //Property "$(property)" does not exist

// let demoNode = [{
//     tagName: 'ul',
//     props: {'class': 'list'},
//     children: [
//         {tagName: 'li', children: ['douyin']},
//         {tagName: 'li', children: ['toutiao']}
//     ]
// }]; 

// function template(node){
//    let str = ''
//       for(let i = 0; i<node.length;i++){
//          let child = ''
//          let { tagName , children , props} = node[i]
//          if(children.length>0){
//             child += childrenTemplate(children)
//          }
         
//          str+=`
//             <${tagName} ${style(props)}>
//                ${child}
//             </${tagName}>
//          `

//       }
//    return str
// }

// function childrenTemplate(childrenNode){
//    let child = '',temp =''
//    for(let i=0; i<childrenNode.length;i++){
//       let { tagName , children , props} = childrenNode[i]
//       if(children.length>0&children.tagName){
//             child += childrenTemplate(children)
//       }else{
//          child =children
//       }
//       temp += `
//             <${tagName} ${style(props)}>
//                ${child}
//             </${tagName}>
//          `
//    }
//    return temp 
// }

// function style(props){
//    let styleStr=''
//    for(propName in props){
//         styleStr+= `${propName} = ${props[propName]}`;
//     }
//    return styleStr
// }

// const html = template(demoNode)

// console.log(html)

// let arr = [3, 5, 5, 5, 6, 7, 8, 9, 10]

// function max(arr){
//    let max = 0;
//    let len = arr.length-1
//    let i = 0
//    let count = 0
//    while(1){
//       if(i>len){
//             return max
//       }
//       if(arr[i] === arr[i+1]){
//             count++
//             max = arr[i]
//       }
//    }
// }

// function max(arr,count){
//    return arr.reduce(function(sum,cur){
//          let index = sum.findIndex(o => o.cur === cur)
//           if (index >= 1) {
//             sum[index].count++
//          } else {
//             sum.push({ count: 1, cur })
//          }
//          return sum
//    },[]).filter(o => o.count >= count).map(o => o.cur)
// }

// console.log(max([1,3,3,3,5,5,5,6,6],1))

//请添加一个所有数组都可找到一个方法findDuplicate(n)数组元素出现频率大于n，返回这些元素组成的数组

//所有 DNA 都由一系列缩写为 A，C，G 和 T 的核苷酸组成，例如：“ACGAATTCCG”。
//在研究 DNA 时，识别 DNA 中的重复序列有时会对研究非常有帮助。

//编写一个函数来查找 DNA 分子中所有出现超过一次的 10 个字母长的序列（子串）。

/*输入：s = "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT"
输出：["AAAAACCCCC", "CCCCCAAAAA"]
*/

/**
 * @param {string} s
 * @return {string[]}
 */
// var findRepeatedDnaSequences = function(s) {
//    let result = []
//    if(s===''||s.length<10){
//       return result
//    }
//    for(let i=0;i<s.length-10;i++){
//       let template = s.substr(i,10)
//       let defualt = s.substr(i+10)
//       if(defualt.match(template)&&defualt.length>0){
//          result.push(template)
//       }else{
//          result.push(template)
//       }
//    }
//    return result
// };
// const dna = findRepeatedDnaSequences("AAAAAAAAAAA")
// console.log(dna)

/**
 * @param {number[][]} matrix
 * @return {number[]}
 */
// var spiralOrder = function(matrix) {
//       //处理每一圈的数据遍历过程
//       let map=(arr, r = [])=>{
//          for(let i=0,len = arr.length;i<len;i++){
//             if(i===0){
//                //如果是第一行
//                r = r.concat(arr[i])
//             }else if(i===len-1){
//                //如果是最后一行
//                r = r.concat(arr[i].reverse())
//             }else{
//                r.push(arr[i].pop())
//             }
//          }
//          arr.shift() //第一行弹出
//          arr.pop() //第二行弹出

//          for(let i= arr.length -1 ; i>=0 i--){
//            r.push(arr[i].shift())
//          }
//          if(arr.length){
//             return map(arr,r)
//          }
//       }
// };

/**
   全排列 --回溯算法
 * @param {number[]} nums
 * @return {number[][]}
 */
// var permute = function(nums) {
//    //[1,2,3] => [1,3,2] 
//    //双指针？ 第一个指针来循环数组 第二个指针不超过数组的长度？
//    let j=0
//    let result = []
//    for(leti=0,len=nums.length;i<len;i++;){
//       let arr = []
//       //每一次的数字 nums[i]
//       while(j<len){
//          arr.push(nums[i])
//       }
//    }

//    return result
// };
// var permute = function(nums) {
//     let n = nums.length;
//     let res = [];
//     let tmpPath = [];
//     let backtrack = (tmpPath) => {
//         if(tmpPath.length == n){
//             res.push(tmpPath);
//             return;
//         }
//         for(let i = 0;i < n;i++){
//             if(!tmpPath.includes(nums[i])){
//                 tmpPath.push(nums[i]);
//                 backtrack(tmpPath.slice());
//                 tmpPath.pop();
//             }
//         }
//     }
//     backtrack(tmpPath);
//     return res;
// };
//通过搜索所有可能的候选解，

var permute = function(nums) {
   let len = nums.length
   let res = [] //最后输出
   let arr = []
   let back =()=>{ //递归
      if(arr.length === len){ ///? 这里的arr的
            return res.push()
      }
   }

}